#!/usr/bin/env node

const fs = require('fs');
const path = require('path');
const { execSync } = require('child_process');
const process = require('process');

// 解析命令行参数
function parseArguments() {
    const args = process.argv.slice(2);
    
    // 简单的命令行参数解析
    const options = {
        inputDir: null,
        outputFile: null,
        tileType: 'image', // 默认类型
        format: 'png',     // 默认格式
        scheme: 'xyz',     // 默认坐标方案
        overlayCoords: false,
        help: false
    };
    
    // 解析参数
    for (let i = 0; i < args.length; i++) {
        const arg = args[i];
        
        if (arg === '-i' || arg === '--input') {
            options.inputDir = args[++i];
        } else if (arg === '-o' || arg === '--output') {
            options.outputFile = args[++i];
        } else if (arg === '-t' || arg === '--type') {
            options.tileType = args[++i];
        } else if (arg === '-f' || arg === '--format') {
            options.format = args[++i];
        } else if (arg === '-s' || arg === '--scheme') {
            options.scheme = args[++i];
        } else if (arg === '-c' || arg === '--overlayCoords') {
            options.overlayCoords = true;
        } else if (arg === '-h' || arg === '--help') {
            options.help = true;
        }
    }
    
    return options;
}

function showHelp() {
    console.log('用法: node convertSingleTileset.js [选项]');
    console.log('');
    console.log('选项:');
    console.log('  -i, --input <目录>   指定输入的瓦片目录');
    console.log('  -o, --output <文件>  指定输出的.mbtiles文件路径');
    console.log('  -t, --type <类型>    指定瓦片扩展名 (png, jpg, pbf...)');
    console.log('  -f, --format <格式>  指定瓦片格式 (png, jpg, webp等)，默认: png');
    console.log('  -s, --scheme <方案>  指定坐标方案 (xyz, tms)，默认: xyz');
    console.log('  -c, --overlayCoords  是否在瓦片上叠加z/x/y坐标信息，默认: 不叠加');
    console.log('  -h, --help           显示帮助信息');
    console.log('');
    console.log('示例:');
    console.log('  node convertSingleTileset.js --input ./offline-maps/image --output ./mbtiles/custom-image.mbtiles --type image --format png --scheme xyz');
    console.log('  node convertSingleTileset.js --input ./offline-maps/image --output ./mbtiles/custom-image.mbtiles --type image --format png --scheme xyz --overlayCoords');
}

function checkDependencies() {
    console.log('===== 检查依赖 =====');
    
    try {
        // 检查node-mbutil是否存在于tools目录
        const mbutilPath = path.join(__dirname, '../../tools/node-mbutil/mbutil.js');
        if (fs.existsSync(mbutilPath)) {
            console.log('✓ node-mbutil 已存在');
            return true;
        } else {
            console.error('✗ node-mbutil 未找到，请确保已克隆子模块');
            return false;
        }
    } catch (error) {
        console.error('✗ 依赖检查失败:', error.message);
        return false;
    }
}

function generateMetadata(tileDir, tileType) {
    const metadataPath = path.join(tileDir, 'metadata.json');
    
    // 定义基础元数据
    const metadata = {
        name: `${tileType} Tiles`,
        description: `${tileType} 瓦片集`,
        version: '1.0.0',
        type: 'baselayer',
        format: 'pbf',
        scheme: 'xyz',
        minzoom: 0,
        maxzoom: 18,
        bounds: "-180,-90,180,90"
    };
    
    // 根据瓦片类型调整格式
    metadata.format = tileType;
    
    console.log(`生成metadata.json: ${metadataPath}`);
    fs.writeFileSync(metadataPath, JSON.stringify(metadata, null, 2));
    return metadataPath;
}

function convertTilesToMbtiles(tileDir, outputFile, tileType, format = 'png', scheme = 'xyz', overlayCoords = false) {
    const mbutilPath = path.join(__dirname, '../../tools/node-mbutil/mbutil.js');
    
    console.log(`\n开始转换: ${path.basename(tileDir)} -> ${path.basename(outputFile)}`);
    console.log(`瓦片类型: ${tileType}`);
    console.log(`格式: ${format}, 坐标方案: ${scheme}`);
    console.log(`坐标叠加: ${overlayCoords ? '启用' : '禁用'}`);
    
    // 确保输出目录存在
    const outputDir = path.dirname(outputFile);
    if (!fs.existsSync(outputDir)) {
        console.log(`创建输出目录: ${outputDir}`);
        fs.mkdirSync(outputDir, { recursive: true });
    }
    
    // 检查输入目录
    if (!fs.existsSync(tileDir)) {
        console.error(`✗ 输入目录不存在: ${tileDir}`);
        return false;
    }
    
    // 检查输出文件是否已存在
    if (fs.existsSync(outputFile)) {
        console.log(`删除已存在的文件: ${outputFile}`);
        fs.unlinkSync(outputFile);
    }
    
    let metadataPath = null;
    let generatedMetadata = false;
    
    try {
        // 检查输入目录是否已存在metadata.json文件
        const existingMetadataPath = path.join(tileDir, 'metadata.json');
        if (fs.existsSync(existingMetadataPath)) {
            console.log(`✓ 使用现有metadata.json文件: ${existingMetadataPath}`);
            metadataPath = existingMetadataPath;
        } else {
            // 生成新的metadata.json文件
            console.log(`生成新的metadata.json文件`);
            metadataPath = generateMetadata(tileDir, tileType);
            generatedMetadata = true;
        }
        
        // 使用node-mbutil将瓦片目录转换为mbtiles文件
        let command = `node ${mbutilPath} --from ${tileDir} --to ${outputFile} --format ${format} --scheme ${scheme} --silent`;
        if (overlayCoords) {
            command += ' --overlayCoords true';
        }
        console.log(`执行命令: ${command}`);
        execSync(command, { stdio: 'inherit' });
        
        console.log(`✓ 转换完成`);
        return true;
    } catch (error) {
        console.error(`✗ 转换失败: ${error.message}`);
        return false;
    } finally {
        // 只清理我们生成的metadata.json文件，不清理用户已有的文件
        if (metadataPath && generatedMetadata && fs.existsSync(metadataPath)) {
            try {
                //fs.unlinkSync(metadataPath);
                //console.log(`已清理临时文件: ${metadataPath}`);
            } catch (cleanupError) {
                console.warn(`清理临时文件失败: ${cleanupError.message}`);
            }
        }
    }
}

function main() {
    console.log('===== 单个瓦片集转MBTiles工具 =====');
    
    const options = parseArguments();
    
    // 显示帮助信息
    if (options.help || !options.inputDir || !options.outputFile) {
        showHelp();
        process.exit(options.help ? 0 : 1);
    }
    
    // 标准化路径
    const tileDir = path.resolve(options.inputDir);
    const outputFile = path.resolve(options.outputFile);
    
    // 检查依赖
    if (!checkDependencies()) {
        console.error('依赖检查失败，请检查环境配置');
        process.exit(1);
    }
    
    // 执行转换
    const success = convertTilesToMbtiles(tileDir, outputFile, options.tileType, options.format, options.scheme, options.overlayCoords);
    
    console.log('\n===== 转换过程结束 =====');
    
    if (success) {
        console.log(`成功将瓦片目录转换为: ${outputFile}`);
        console.log('提示: 要在服务中使用这个MBTiles文件，请确保在.env文件中设置正确的配置');
        process.exit(0);
    } else {
        console.error('转换失败，请检查错误信息');
        process.exit(1);
    }
}

// 执行主函数
if (require.main === module) {
    main();
} else {
    // 如果作为模块导入，导出主要函数供其他地方使用
    module.exports = {
        convertTilesToMbtiles,
        checkDependencies
    };
}